# -*- coding: utf-8 -*-

 ###############################################
 ##                                             ##
 ##   Empresa Básica                             ##
 ##   Módulo de pedidos                          ##
 ##   Interfase gráfica                          ##
 ##                                              ##
 ##   por Críptidos Digitales                    ##
 ##   GPL (c)2008                                ##
  ##                                             ##
    ###############################################

# print (0), "  pedidos.igu       begin"

import sys
from decimal import Decimal as dec
from PyQt4 import QtCore, QtGui
import xlwt
import datetime
from cdWidgets import cdFrame, cdLineEdit, cdNumberEdit

import frame_ui
import administradorPedidos_ui as administrador_ui
import capturaPedido_ui as captura_ui
import detallesPedido_ui as detalles_ui

# import informacion

import manejador
import utilities
if cdLineEdit.version < 2.1:
    print u"Debe actualizar la versión del módulo cdLineEdit a 2.1 o posterior"

CODIGO, NOMBRE, LINEA, CANTIDAD, PRECIO, IMPORTE = range(6)

# print (0), "  pedidos.igu         definitions"


class Forma(cdFrame.CDFrame):

    @property
    def app(self):
        return self.__app

    @property
    def eventRouter(self):
        return self.__eventRouter

    def __init__(self, *args, **kwds):
        m = "pedidos.igu.Forma.__init__()"

        if kwds.has_key('app'):
            self.__app = kwds.pop('app')
        else:
            self.__app = None

        if 'eventRouter' in kwds.keys():
            self.__eventRouter = kwds.pop('eventRouter')
        else:
            self.__eventRouter = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = frame_ui.Ui_Form()
        self.ui.setupUi(self)

        self.ui.frame1.close()
        self.ui.frame2.close()
        self.ui.frame3.close()

        ## Detalles
        self.detalles = Detalles(self, owner=self)
        self.detalles.hide()
        self.detalles.status = 'normal'

        ## Captura
        self.captura = Captura(self, owner=self)
        self.connect(self.captura, QtCore.SIGNAL('capturaClosed()'), self.capturaClosed)
        self.captura.hide()

        ## Administrador
        self.administrador = Administrador(self, owner=self)

        self.ui.outerSplitter = Splitter(QtCore.Qt.Vertical, self)
        ## InnerSplitter
        self.ui.innerSplitter = Splitter(QtCore.Qt.Horizontal, self.ui.outerSplitter)
        self.ui.innerSplitter.insertWidget(0, self.administrador)
        self.ui.innerSplitter.insertWidget(1, self.detalles)
        self.connect(self.ui.innerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.innerHandlePressed)
        self.ui.innerSplitter.setSizes([1, 1])

        ## OuterSplitter
        self.ui.outerSplitter.insertWidget(0, self.ui.innerSplitter)
        self.ui.outerSplitter.insertWidget(1, self.captura)
        self.connect(self.ui.outerSplitter.handle(1), QtCore.SIGNAL('handlePressed'), self.outerHandlePressed)
        self.ui.outerSplitter.setSizes([1, 1])
        self.ui.verticalLayout.addWidget(self.ui.outerSplitter)

    def capturaClosed(self):                # print "pedidos.igu.Forma.capturaClosed()"
        self.setInnerStatus("visible")
        self.administrador.actualizaBotones()


    def innerHandlePressed(self):           # print "pedidos.igu.Forma.innerHandlePressed()"
        self.toggleDetalles()


    def outerHandlePressed(self):           # print "pedidos.igu.Forma.outerHandlePressed()"
        if self.ui.outerSplitter.sizes()[0] == 0:
            self.setInnerStatus('visible')
        else:
            self.setInnerStatus('hidden')


    @property
    def owner(self):
        return self.__owner


    def setInnerStatus(self, value):        # print "pedidos.igu.Forma.setInnerStatus(%s)" % value
        if value == 'visible':
            self.administrador.show()
            if self.detalles.status == 'hidden':
                self.detalles.show()
                self.detalles.status = "normal"

        elif value == 'hidden':
            self.administrador.hide()
            if self.detalles.isVisible():
                self.detalles.status = "hidden"
                self.detalles.hide()

        elif value == 'disabled':
            print 'disables'


    def toggleDetalles(self, *args):        # print "pedidos.igu.Forma.toggleDetalles()"
        if self.detalles.isVisible():
            self.detalles.hide()
        else:
            self.setCursor(QtCore.Qt.WaitCursor)

            id = self.administrador.ui.tablaConsulta.item(self.administrador.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]

            self.detalles.actualiza(id)
            self.detalles.show()

            self.setCursor(QtCore.Qt.ArrowCursor)


class Administrador(cdFrame.CDFrame):

    @property
    def eventRouter(self):
        return self.__owner.eventRouter


    def __init__(self, *args, **kwds):
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = administrador_ui.Ui_Form()
        self.ui.setupUi(self)

        ## FILTROS
        self.ui.laProveedor.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")
        self.ui.laStatus.setStyleSheet("QLabel:enabled{background-color:#0000FF; color:#FFFFFF;}")

        self.connect(self.ui.ch1, QtCore.SIGNAL('stateChanged(int)'), self.actualizaConsulta)
        self.connect(self.ui.ch2, QtCore.SIGNAL('stateChanged(int)'), self.actualizaConsulta)

        font = QtGui.QFont()
        font.setBold(True)
        font.setPointSize(9)
        self.ui.cbProveedor.setFont(font)
        self.cargaProveedores()
        self.connect(self.ui.cbProveedor, QtCore.SIGNAL("currentIndexChanged(int)"), self.actualizaConsulta)

        ## TABLA DE CONSULTA
        # self.ui.tablaConsulta.setStyleSheet("background-color:#FFFFFF")
        self.ui.tablaConsulta.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
        self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.labels = [u"Id", u"Folio", u"Fecha", u"Status", u"Monto", u"Proveedor"]
        self.ui.tablaConsulta.setColumnCount(len(self.labels))
        self.ui.tablaConsulta.setHorizontalHeaderLabels(self.labels)
        self.ui.tablaConsulta.hideColumn(0)
        self.ui.tablaConsulta.horizontalHeader().setResizeMode(5, QtGui.QHeaderView.Stretch)
        self.ui.tablaConsulta.setToolTip(u"ALT+D muestra detalles de la Orden seleccionada")

        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        # self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("currentItemChanged(QTableWidgetItem *,QTableWidgetItem *)"), self.currentChanged)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)
        self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("resized(QEvent)"), self.resizedTablaConsulta)

        ## Agregar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Plus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aAgregar = QtGui.QAction(icon, u"Agregar", self)
        self.aAgregar.setCheckable(True)
        self.aAgregar.setIconText(u"&Agregar")
        self.connect(self.aAgregar, QtCore.SIGNAL("triggered()"), self.agrega)

        self.ui.toAgregar.setDefaultAction(self.aAgregar)
        self.ui.toAgregar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toAgregar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Modificar
        icon1 = QtGui.QIcon()
        icon1.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aModificar = QtGui.QAction(icon1, u"Modificar", self)
        self.aModificar.setCheckable(True)
        self.aModificar.setIconText("&Modificar")
        self.connect(self.aModificar, QtCore.SIGNAL("triggered()"), self.modifica)

        self.ui.toModificar.setDefaultAction(self.aModificar)
        self.ui.toModificar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toModificar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Eliminar
        icon2 = QtGui.QIcon()
        icon2.addPixmap(QtGui.QPixmap("imagenes/Minus.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aEliminar = QtGui.QAction(icon2, u"Eliminar", self)
        self.aEliminar.setCheckable(True)
        self.aEliminar.setIconText("&Eliminar")
        self.connect(self.aEliminar, QtCore.SIGNAL("triggered()"), self.elimina)

        self.ui.toEliminar.setDefaultAction(self.aEliminar)
        self.ui.toEliminar.setIconSize(QtCore.QSize(44, 40))
        self.ui.toEliminar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Detalles
        self.aDetalles = QtGui.QAction("Detalles", self)
        self.aDetalles.setShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_D))
        #~ self.connect(self.aDetalles, QtCore.SIGNAL("triggered()"), self.detallesTriggered)

        ## Imprimir
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.aImprimir = QtGui.QAction(icon, u"Imprimir", self)
        self.aImprimir.setIconText(u"&Imprimir")
        self.connect(self.aImprimir, QtCore.SIGNAL("triggered()"), self.imprime)

        self.ui.toImprimir.setDefaultAction(self.aImprimir)
        self.ui.toImprimir.setIconSize(QtCore.QSize(44, 40))
        self.ui.toImprimir.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)

        ## Menu
        self.menuTablaConsulta = QtGui.QMenu(self)
        self.menuTablaConsulta.addAction(self.aAgregar)
        self.menuTablaConsulta.addAction(self.aModificar)
        self.menuTablaConsulta.addAction(self.aEliminar)

        self.connect(self.eventRouter, QtCore.SIGNAL('pedidosChangedBroadcast()'), self.actualizaConsulta)
        self.connect(self.eventRouter, QtCore.SIGNAL('productosChangedBroadcast()'), self.actualizaBotones)
        self.connect(self.eventRouter, QtCore.SIGNAL('proveedoresChangedBroadcast()'), self.proveedoresChanged)

        self.actualizaConsulta()

        self.setFocusPolicy(QtCore.Qt.StrongFocus)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)


    def proveedoresChanged(self):
        self.cargaProveedores()
        self.actualizaConsulta()


    def actualizaBotones(self):
        if not self.owner.captura.isVisible():
            self.aAgregar.setChecked(False)
            self.aModificar.setChecked(False)
        self.aEliminar.setChecked(False)
        self.aImprimir.setChecked(False)

        mensajesFiltros = u""
        mensajesAlta = u""
        mensajesModifica = u""
        mensajesElimina = u""
        mensajesImprime = u""
        self.mensajesInfo = u""

        if manejador.totalDeProductos() == 0:
            mensajesAlta += u"No hay productos registrados\n"
            self.mensajesInfo += u"Debe registrar los productos\n"
        if manejador.totalDeProveedores() == 0:
            mensajesAlta += u"No hay proveedores registrados\n"
            mensajesFiltros += u"No hay proveedores registrados\n"
            self.mensajesInfo += u"Debe registrar proveedores\n"

        if manejador.totalDeOrdenesDeCompra() == 0:
            mensajesFiltros += u"No hay órdenes de compra registradas\n"
            mensajesModifica += u"No hay órdenes de compra registradas\n"
            mensajesElimina += u"No hay órdenes de compra registradas\n"
            mensajesImprime += u"No hay órdenes de compra para imprimir\n"
        elif self.ui.tablaConsulta.rowCount() == 0:
            mensajesModifica += u"No hay órdenes de compra desplegadas\n"
            mensajesElimina += u"No hay órdenes de compra desplegadas\n"
            mensajesImprime += u"No hay órdenes de compra desplegadas\n"
        elif self.ui.tablaConsulta.rowCount() > 0:
            if self.ui.tablaConsulta.currentRow() == -1:
                mensajesModifica += u"Selecciona la Orden de Compra que quieres Modificar"
                mensajesElimina += u"Selecciona la Orden de Compra que quieres Eliminar"

        if mensajesFiltros:
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
            self.ui.frFiltros.setEnabled(False)
            self.ui.frProveedor.setToolTip(u"")
            self.ui.frFiltros.setToolTip(mensajesFiltros.rstrip("\n"))
        else:
            self.ui.frFiltros.setEnabled(True)
            self.ui.frFiltros.setToolTip(u"")

        if mensajesAlta:
            self.aAgregar.setEnabled(False)
            self.aAgregar.setToolTip(mensajesAlta.rstrip("\n"))
        else:
            self.aAgregar.setEnabled(True)
            self.aAgregar.setToolTip(u"Presiona para registrar una Orden de Compra nueva")

        # self.aModificar.setEnabled(False)
        # self.aModificar.setToolTip(u"La modificación de Órden de compra no está implementada")
        if mensajesModifica:
            self.aModificar.setEnabled(False)
            self.aModificar.setToolTip(mensajesModifica.rstrip("\n"))
        else:
            self.aModificar.setEnabled(True)
            self.aModificar.setToolTip(u"Presiona para modificar los datos de la Orden de Compra seleccionada")

        if mensajesElimina:
            self.aEliminar.setEnabled(False)
            self.aEliminar.setToolTip(mensajesElimina.rstrip("\n"))
        else:
            self.aEliminar.setEnabled(True)
            self.aEliminar.setToolTip(u"Presiona para eliminar la Orden de compra seleccionada")

        if mensajesImprime:
            self.aImprimir.setEnabled(False)
            self.aImprimir.setToolTip(mensajesImprime.rstrip("\n"))
        else:
            self.aImprimir.setEnabled(True)
            self.aImprimir.setToolTip(u"Presiona para Imprimir las compras mostradas")

        if self.mensajesInfo:
            self.owner.owner.informacion = self.mensajesInfo
        else:
            self.owner.owner.informacion = u""


    def actualizaConsulta(self, *args):         # print "pedidos.igu.Administrador.actualizaConsulta()"
        filtros = {}

        if self.ui.cbProveedor.currentIndex() > 0:
            filtros['rol_id'] = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]

        old = self.currentId()

        all = 0
        status = []
        if self.ui.ch1.isChecked():
            status.append(u'abierto')
            all += 1
        if self.ui.ch2.isChecked():
            status.append(u'cerrado')
            all += 1

        if not all == 2:
            filtros['status'] = status

        procesos = manejador.dameProcesos(**filtros)

        self.ui.tablaConsulta.setSortingEnabled(False)

        self.ui.tablaConsulta.setRowCount(0)

        for indexProceso, proceso in enumerate(procesos):

            operacionSolicitudZero = [x for x in proceso.operaciones if x.tipo==u'solicitud']

            if operacionSolicitudZero:
                documento = operacionSolicitudZero[0].documentos[0]

                self.ui.tablaConsulta.insertRow(0)

                item = QtGui.QTableWidgetItem("")
                item.setData(1000, QtCore.QVariant(proceso.id))
                self.ui.tablaConsulta.setItem(0, 0, item)

                item = QtGui.QTableWidgetItem("%s" % documento.folio)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                self.ui.tablaConsulta.setItem(0, 1, item)

                item = QtGui.QTableWidgetItem(documento.fecha.strftime("%d %b %Y"))
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                self.ui.tablaConsulta.setItem(0, 2, item)

                item = QtGui.QTableWidgetItem(documento.status.capitalize())
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                self.ui.tablaConsulta.setItem(0, 3, item)

                item = QtGui.QTableWidgetItem("%.2f" % documento.total)
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                item.setTextAlignment(QtCore.Qt.AlignCenter)
                self.ui.tablaConsulta.setItem(0, 4, item)

                item = QtGui.QTableWidgetItem("%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))
                item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.ui.tablaConsulta.setItem(0, 5, item)

        self.ui.tablaConsulta.setSortingEnabled(True)

        self.setCurrentId(old)

        self.actualizaBotones()


    def agrega(self):                   # print "pedidos.igu.Administrador.agrega()"
        self.owner.captura.agrega()


    def cargaProveedores(self):         # print "pedidos.igu.Administrador.cargaProveedores()"
        old = self.ui.cbProveedor.itemData(self.ui.cbProveedor.currentIndex()).toInt()[0]
        self.ui.cbProveedor.clear()
        proveedores = manejador.dameProveedores()

        if proveedores:
            self.ui.cbProveedor.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
            for rol in proveedores:
                self.ui.cbProveedor.addItem("%s %s" % (rol.entidad.nombre, rol.entidad.nombre2), QtCore.QVariant(rol.id))
        else:
            self.ui.cbProveedor.addItem("No hay proveedores", QtCore.QVariant(self.owner.app.holder.id))
            self.ui.frProveedor.setToolTip(u"No hay proveedores capturados")

        if old > 0:
            self.ui.cbProveedor.setCurrentIndex(self.ui.cbProveedor.findData(old))
        else:
            self.ui.cbProveedor.setCurrentIndex(0)


    def currentId(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
        else:
            id = None
        return id

    def detallesTriggered(self):
        print "pedidos.igu.Captura.detallesTriggered()"


    def elimina(self):
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar Orden de compra", u"Selecciona la orden de compra que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            dato = manejador.dameUno(id=id)
            if dato.status == u"Pendiente":
                result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar Orden de compra", u"¿Realmente quieres ELIMINAR la ORDEN DE COMPRA %s %s?" % (dato.folio, dato.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                if result == QtGui.QMessageBox.Yes:
                    manejador.elimina(id=id)
                    self.app.forma.emit(QtCore.SIGNAL("pedidosChangedBroadcast()"))
            else:
                result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar Orden de compra", u"Lo siento, esta orden de compra ya ha sido procesada, NO SE PUEDE ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
            self.actualizaBotones()

    def findData(self, data):
        index = -1
        for row in range(self.ui.tablaConsulta.rowCount()):
            if self.ui.tablaConsulta.item(row, 0).data(1000)==QtCore.QVariant(data):
                index = row
        return index

    # def hideInfo(self):
        # self.frame.hide()


    def imprime(self):
        print "pedidos.igu.Administrador.imprime()"
        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:
            painter = QtGui.QPainter(self.impresor)
            margenHorizontal, margenVertical = [10, 10]

            font1 = QtGui.QFont("courier", 10)
            font1.setBold(True)
            font2 = QtGui.QFont("courier", 9)
            font3 = QtGui.QFont("Courier", 12)
            font3.setBold(True)

            margenX, margenY = [25, 75]
            pageWidth, pageHeight = (self.impresor.paperRect().width(), self.impresor.paperRect().height())
            pageNo = 1

            ## HEADER
            header = []
            x, y = [25, 0]
            header.append([pageWidth/2-100, margenY+y, u"Catálogo de Empleados", font3])
            x, y = [400, 25]
            header.append([pageWidth-200, margenY+y, u"Fecha: %s" % QtCore.QDate().currentDate().toString('dd MMM yyyy'), font1])

            # x, y = [0, 100]
            # header.append([margenX+x, margenY+y, u"    Nombre                                     RFC            Teléfonos", font1])

            tabla = self.ui.tablaConsulta

            x, y = [0, 75]
            contenido = []
            footer = []
            offset = 0
            for row in range(tabla.rowCount()):
                if offset == 0:
                    contenido.extend(header)
                posX, posY = (margenX + x, margenY + y + offset)
                contenido.append([posX    , posY, str(row+1), font2])
                contenido.append([posX+40 , posY, tabla.item(row, 0).text(), font2])    # Nombre
                contenido.append([posX+90 , posY+18, tabla.item(row, 4).text(), font2]) # Domicilio
                contenido.append([posX+90 , posY+36, tabla.item(row, 3).text(), font2]) # Lugar
                contenido.append([posX+90 , posY+54, u"RFC: %s   Teléfonos: %s" % (tabla.item(row, 1).text(), tabla.item(row, 2).text()), font2]) # RFC, Teléfono
                # if tabla.item(row, 5):
                    # contenido.append([posX+690, posY, tabla.item(row, 5).text(), font2])# Importe
                offset += 80
                if posY+190 >= pageHeight:
                    contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
                    for item in contenido:
                        painter.setFont(item[3])
                        painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])
                    offset = 0
                    contenido = []
                    footer = []
                    pageNo += 1
                    self.impresor.newPage()

            contenido.append([pageWidth/2-50, pageHeight-50, "Hoja %s" % pageNo, font2])
            for item in contenido:
                painter.setFont(item[3])
                painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])


    def modifica(self):                 # print "pedidos.igu.Administrador.modifica()"
        if self.ui.tablaConsulta.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Modificar Orden de compra", u"Selecciona la ORDEN DE COMPRA que quieres MODIFICAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            self.setCursor(QtCore.Qt.WaitCursor)
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            self.owner.captura.modifica(id)
            self.setCursor(QtCore.Qt.ArrowCursor)


    def mostrarMenuConsulta(self, pos):
        pos = self.ui.tablaConsulta.mapToGlobal(pos)
        self.menuTablaConsulta.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def resizedTablaConsulta(self, event): # print "pedidos.igu.Administrador.resizedTablaConsulta()"
        headerWidth = self.ui.tablaConsulta.width()-self.ui.tablaConsulta.verticalHeader().width()-self.ui.tablaConsulta.verticalScrollBar().width()
        self.ui.tablaConsulta.horizontalHeader().setMinimumWidth(headerWidth)

        porcentajes = [0, 10, 15, 15, 15]
        overflow = 0

        for index in range(self.ui.tablaConsulta.horizontalHeader().count()-1):

            if not self.ui.tablaConsulta.isColumnHidden(index):
                self.ui.tablaConsulta.resizeColumnToContents(index)

                porContenido = self.ui.tablaConsulta.columnWidth(index)
                calculado = headerWidth * porcentajes[index] / 100

                if porContenido < calculado:
                    if overflow:
                        offset = calculado - porContenido
                        if offset > overflow:
                            calculado = calculado - overflow
                            overflow = 0
                        else:
                            overflow -= offset
                            calculado = porContenido
                    self.ui.tablaConsulta.setColumnWidth(index, calculado)
                else:
                    overflow += porContenido - calculado


    def selectionChanged(self):
        if self.ui.tablaConsulta.currentRow() != -1:
            id = self.ui.tablaConsulta.item(self.ui.tablaConsulta.currentRow(), 0).data(1000).toInt()[0]
            if self.owner.detalles.isVisible():
                self.owner.detalles.actualiza(id)
            if self.owner.captura.isVisible():
                if self.owner.captura.modo == 'modificar':
                    if self.owner.captura.id != id:
                        if self.owner.captura.estaModificado():
                            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Modificación de Orden de compra", u"La captura de Orden de compra tiene cambios\n\n¿Quieres Guardar los cambios para %s %s %s?" % (self.owner.captura.old.tipo, self.owner.captura.old.folio, self.owner.captura.old.fecha), QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
                            if result == QtGui.QMessageBox.Yes:
                                self.owner.captura.guarda()
                        self.owner.captura.modifica(id)
        self.actualizaBotones()


    def setCurrentId(self, id):
        self.ui.tablaConsulta.setCurrentItem(self.ui.tablaConsulta.item(self.findData(id), 0))


    def showed(self):
        self.owner.owner.informacion = u""


class Captura(cdFrame.CDFrame):

    @property
    def eventRouter(self):
        return self.owner.eventRouter

    @property
    def modo(self):
        return self.__modo

    def __init__(self, *args, **kwds):  # print "pedidos.igu.Captura.__init__()"
        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        self.__modo = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = captura_ui.Ui_Form()
        self.ui.setupUi(self)

        self.__status = u'normal'

        self.ui.frame.setStyleSheet("background-color:#E0E0E0;")
        self.connect(self.ui.frame, QtCore.SIGNAL('returnPressed()'), self.returnPressed)

        ## Fecha
        self.ui.fecha.setDisplayFormat("dd MMM yyyy")
        self.ui.fecha.setMaximumDate(QtCore.QDate().currentDate())

        ## Tabla partidas
        self.ui.tablaPartidas = TablaPartidas(self.ui.frameCaptura, modo=self.modo, owner=self)
        # self.ui.tablaPartidas.setSizePolicy(sizePolicy)
        self.ui.tablaPartidas.setStyleSheet("background-color:#FFFFFF;")
        labels = [u"Código", u"Nombre", u"Línea", u"Cantidad", u"Precio", u"Importe"]
        self.ui.tablaPartidas.setColumnCount(len(labels))
        self.ui.tablaPartidas.setHorizontalHeaderLabels(labels)
        self.ui.tablaPartidas.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)
        self.ui.layoutCaptura.insertWidget(3, self.ui.tablaPartidas)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL("totalChanged(dec)"), self.totalChanged)
        self.connect(self.ui.tablaPartidas, QtCore.SIGNAL('editingFinished()'), self.partidaCapturada)

        ## Proveedores
        self.connect(self.ui.cbEntidad, QtCore.SIGNAL("currentIndexChanged(int)"), self.setRol)
        self.cargaProveedores()

        self.cargaCondiciones()

        ## Cargar Lista
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCargarLista.setIcon(icon)
        self.ui.boCargarLista.setToolTip(u"Presione para cargar la lista de todos los productos del proveedor")
        self.connect(self.ui.boCargarLista, QtCore.SIGNAL("clicked()"), self.cargaLista)

        ## Origen de datos
        self.cargaOrigenes()
        self.connect(self.ui.cbOrigen, QtCore.SIGNAL('activated(int)'), self.origenChanged)

        ## Codigo de Producto
        completer = QtGui.QCompleter([], self.ui.edCodigoProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        model = Model(completer)
        completer.setModel(model)
        self.ui.edCodigoProducto.setCompleter(completer)

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.codigoProductoSeleccionado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('returnPressed()'), self.codigoProductoCapturado)
        # self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('editingFinished()'), self.codigoProductoCapturado)
        self.connect(self.ui.edCodigoProducto, QtCore.SIGNAL('textEdited(QString)'), self.codigoProductoEditado)

        ## Nombre de Producto
        completer = QtGui.QCompleter([], self.ui.edNombreProducto)
        completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
        model = Model(completer)
        completer.setModel(model)
        self.ui.edNombreProducto.setCompleter(completer)

        # size = self.ui.edNombreProducto.completer().popup().gridSize()
        # self.ui.edNombreProducto.completer().popup().setMinimumHeight(200)
        # self.ui.edNombreProducto.completer().popup().setGridSize(size)

        self.connect(completer, QtCore.SIGNAL("activated(QModelIndex)"), self.nombreProductoSeleccionado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL('returnPressed()'), self.nombreProductoCapturado)
        self.connect(self.ui.edNombreProducto, QtCore.SIGNAL("textEdited(QString)"), self.nombreProductoEditado)

        ## Linea
        self.cargaLineas()

        ## Subtotal
        self.ui.edSubtotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edSubtotal.setAlignment(QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
        self.ui.edSubtotal.setRange(0, 99999)

        ## Descuento
        self.ui.edDescuento.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edDescuento.setAlignment(QtCore.Qt.AlignTrailing)
        self.ui.edDescuento.setRange(0, 99999)

        ## Porcentaje de descuento
        self.ui.edDescuentoPorcentaje.setAlignment(QtCore.Qt.AlignCenter)
        self.ui.edDescuentoPorcentaje.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5)/2)
        self.ui.edDescuentoPorcentaje.setEmptyAllowed(True)
        self.ui.edDescuentoPorcentaje.setRange(0, 75)
        self.ui.edDescuentoPorcentaje.setDecimals(-1)
        self.connect(self.ui.edDescuentoPorcentaje, QtCore.SIGNAL("editingFinished()"), self.porcentajesChanged)

        ## Impuesto
        self.ui.edImpuesto.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edImpuesto.setAlignment(QtCore.Qt.AlignTrailing)
        self.ui.edImpuesto.setRange(0, 99999)

        ## Porcentaje de impuesto
        self.ui.edImpuestoPorcentaje.setAlignment(QtCore.Qt.AlignCenter)
        self.ui.edImpuestoPorcentaje.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5)/2)
        impuesto = manejador.impuestoGeneral()
        self.ui.edImpuestoPorcentaje.setText("%s" % impuesto)
        self.connect(self.ui.edImpuestoPorcentaje, QtCore.SIGNAL("editingFinished()"), self.porcentajesChanged)

        ## Total
        self.ui.edTotal.setAlignment(QtCore.Qt.AlignRight)
        self.ui.edTotal.setMaximumWidth(self.ui.tablaPartidas.columnWidth(5))
        self.ui.edTotal.setRange(0, 99999)

        ## Guardar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Check.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boGuarda.setIcon(icon)
        self.ui.boGuarda.setIconSize(QtCore.QSize(32,32))
        self.ui.boGuarda.setDefault(True)
        # self.ui.boGuarda.setStyleSheet("background-color:#F0F0F0")
        self.connect(self.ui.boGuarda, QtCore.SIGNAL("clicked()"), self.guarda)

        ## Cancelar
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Cancel.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.boCancelar.setIcon(icon)
        self.ui.boCancelar.setIconSize(QtCore.QSize(32,32))
        # self.ui.boCancelar.setStyleSheet("background-color:#F0F0F0")
        self.connect(self.ui.boCancelar, QtCore.SIGNAL("clicked()"), self.cancela)

        self.connect(self.eventRouter, QtCore.SIGNAL("proveedoresChangedBroadcast()"), self.cargaProveedores)

        self.connect(self, QtCore.SIGNAL('showed()'), self.showed)

        self.impuestoGeneralFactor = (manejador.impuestoGeneral() + dec('100')) / dec('100')

        self.setImpuestoIncluido(False)

        self.__rangoPrecioActual = 0


    def actualizaStatus(self):
        m = "pedidos.igu.Captura.actualizaStatus()"
        print (1), m

        if self.status == u"normal":
            if self.modo == 'modificar':
                if self.estaModificado():
                    if self.esValida():
                        self.ui.boGuarda.setEnabled(True)
                        self.ui.boGuarda.setToolTip(u"")
                    else:
                        self.ui.boGuarda.setEnabled(False)
                        self.ui.boGuarda.setToolTip(self.mensajes)
                else:
                    self.ui.boGuarda.setEnabled(False)
                    self.ui.boGuarda.setToolTip(u"No hay cambios")

            elif self.modo == 'agregar':
                if self.esValida():
                    self.ui.boGuarda.setEnabled(True)
                else:
                    self.ui.boGuarda.setEnabled(False)
                self.ui.boGuarda.setToolTip(self.mensajes)


    def agrega(self):
        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "ORDEN DE COMPRA NUEVA", None, QtGui.QApplication.UnicodeUTF8))
        self.__modo = "agregar"
        self.clear()

        self.ui.edFolio.setText(manejador.dameFolio())
        self.ui.fecha.setDate(QtCore.QDate().currentDate())

        self.ui.cbEntidad.setEnabled(True)

        self.ui.edCodigoProducto.setEnabled(True)
        self.ui.edNombreProducto.setEnabled(True)
        self.ui.cbLinea.setEnabled(True)

        self.ui.edNombreProducto.setFocus()

        self.actualizaStatus()
        self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.show()


    def cancela(self):
        self.clear()
        self.hide()
        self.emit(QtCore.SIGNAL('capturaClosed()'))


    def cargaClasificaciones(self):
        clasificaciones = manejador.dameClasificaciones()
        self.ui.cbClasificacion.clear()
        self.ui.cbClasificacion.addItem("", QtCore.QVariant(-1))
        for clasificacion in clasificaciones:
            self.ui.cbClasificacion.addItem(clasificacion.nombre, QtCore.QVariant(clasificacion.id))


    def cargaCondiciones(self):
        condiciones = manejador.dameCondiciones()
        for item in condiciones:
            self.ui.cbCondiciones.addItem(item.nombre)
        self.ui.cbCondiciones.setCurrentIndex(-1)


    def cargaLineas(self):
        lineas = manejador.lineasProducto()
        self.ui.cbLinea.clear()
        self.ui.cbLinea.addItem("", QtCore.QVariant(-1))
        for linea in lineas:
            self.ui.cbLinea.addItem(linea.nombre, QtCore.QVariant(linea.id))


    def cargaLista(self):
        m = "pedidos.igu.Captura.cargaLista()"
        print (1), m

        self.setCursor(QtCore.Qt.WaitCursor)

        acepciones = manejador.dameAcepciones(rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        self.ui.tablaPartidas.setRowCount(0)

        for index, acepcion in enumerate(acepciones):
            self.ui.tablaPartidas.setDatosRenglon(index, acepcion, dec('0'), acepcion.costo)

        self.ui.boCargarLista.setEnabled(False)
        self.ui.tablaPartidas.setFocus()

        self.setCursor(QtCore.Qt.ArrowCursor)


    def cargaOrigenes(self):
        self.ui.cbOrigen.clear()
        origenes = manejador.dameProveedores()
        self.ui.cbOrigen.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
        for origen in origenes:
            self.ui.cbOrigen.addItem("%s %s" % (origen.entidad.nombre, origen.entidad.nombre2), QtCore.QVariant(origen.id))


    def cargaProveedores(self):
        m = "pedidos.igu.Captura.cargaProveedores()"
        print (1), m

        old = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex())
        self.ui.cbEntidad.clear()
        proveedores = manejador.dameProveedores()
        if proveedores:
            self.ui.cbEntidad.addItem(u"", QtCore.QVariant(self.owner.app.holder.id))
            for rol in proveedores:
                self.ui.cbEntidad.addItem("%s %s" % (rol.entidad.nombre, rol.entidad.nombre2), QtCore.QVariant(rol.id))
        else:
            self.ui.cbEntidad.addItem("Debe dar de alta al proveedor", QtCore.QVariant(self.owner.app.holder.id))
        if old > 0:
            self.ui.cbEntidad.setCurrentIndex(self.ui.cbEntidad.findData(old))


    def clear(self):
        m = "pedidos.igu.Captura.clear()"
        print (1), m

        self.setStatus(u"clearing")

        self.ui.cbEntidad.setCurrentIndex(0)

        self.ui.boCargarLista.setEnabled(True)

        self.ui.cbOrigen.setCurrentIndex(0)
        self.ui.edNombreProducto.clear()
        self.ui.cbLinea.setCurrentIndex(-1)

        self.ui.tablaPartidas.setRowCount(0)
        self.ui.edSubtotal.clear()
        self.ui.edDescuento.clear()
        self.ui.edImpuesto.clear()
        self.ui.edTotal.clear()
        self.ui.laCantidadConLetra.clear()

        self.setStatus(u"normal")


    def codigoProductoCapturado(self):
        m = "pedidos.igu.Captura.codigoProductoCapturado()"
        print (1), m

        if self.ui.edCodigoProducto.completer().completionCount() == 1:
            if self.ui.edCodigoProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edCodigoProducto.completer().completionModel()
                index = model.index(0, 0)
                self.codigoProductoSeleccionado(index)


    def codigoProductoEditado(self, texto):
        m = "pedidos.igu.Captura.codigoProductoEditado()"
        print (1), m

        if len(texto) < 2:
            self.ui.edCodigoProducto.completer().model().clear()

        elif len(texto) == 2:
            filtros = {}
            filtros['codigo'] = unicode(texto).lower()
            filtros['rol_id'] = self.ui.cbOrigen.itemData(self.ui.cbOrigen.currentIndex()).toInt()[0]

            acepciones = manejador.dameAcepciones(**filtros)

            self.ui.edCodigoProducto.completer().model().clear()

            ## Set Model Data
            for row, acepcion in enumerate(acepciones):
                self.ui.edCodigoProducto.completer().model().setData(row, "%s %s" % (acepcion.codigo, acepcion.nombre))
                self.ui.edCodigoProducto.completer().model().setData(row, acepcion.id, 1001)

            self.ui.edCodigoProducto.completer().model().reset()

            # ids = [x.id for x in acepciones]
            # codigos = ["%s" % x.codigo for x in acepciones]

            # self.sender().completer().data = ids
            # self.sender().completer().model().setStringList(codigos)

            if self.ui.edCodigoProducto.text():
                self.ui.frameNombre.setEnabled(False)
                self.ui.frameNombre.setToolTip(u"Desactivado si se busca por codigo")
                self.ui.frameLinea.setEnabled(False)
                self.ui.frameLinea.setToolTip(u"Desactivado si se busca por codigo")
            else:
                self.ui.frameNombre.setEnabled(True)
                self.ui.frameNombre.setToolTip("")
                self.ui.frameLinea.setEnabled(True)
                self.ui.frameLinea.setToolTip(u"")


    def codigoProductoSeleccionado(self, completerModelIndex):
        m = "pedidos.igu.Captura.codigoProductoSeleccionado()"
        print (1), m

        completerRow = completerModelIndex.row()

        model = self.ui.edCodigoProducto.completer().completionModel()

        acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        ## Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        else:
            acepcionRol = acepcionOrigen

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcionRol, cantidad=dec('0.0'), precio=acepcionRol.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(0)

        self.ui.frameNombre.setEnabled(True)
        self.ui.frameNombre.setToolTip("")
        self.ui.frameLinea.setEnabled(True)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


    def data(self):
        datos = {}

        if self.modo == 'modificar':
            datos['id'] = self.id

        # datos['tipoDocumento_id'] = manejador.atributoI(grupo=u'tipoDocumento', nombre=u"pedido").id
        datos['folio'] = unicode(self.ui.edFolio.text())
        datos['fecha'] = self.ui.fecha.date().toPyDate()
        datos['rol_id'] = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]

        datos['subtotal'] = self.ui.edSubtotal.value()
        datos['descuento'] = self.ui.edDescuento.value()
        datos['descuentoPorcentaje'] = self.ui.edDescuentoPorcentaje.value()
        datos['impuesto'] = self.ui.edImpuesto.value()
        datos['impuestoPorcentaje'] = self.ui.edImpuestoPorcentaje.value()
        datos['total'] = self.ui.edTotal.value()

        # datos['status'] = u"pendiente"

        datos['partidas'] = self.ui.tablaPartidas.data()

        return datos


    def estaModificado(self):
        m = "pedidos.igu.Captura.estaModificado()"
        print (1), m

        modificado = False
        self.mensajes2 = u""

        if self.modo == u'modificar':

            data = self.data()

            ## Solicitud
            operacionSolicitudCero = [x for x in self.old.operaciones if x.tipo==u'solicitud']

            documento = operacionSolicitudCero[0].documentos[0]

            try:
                if documento.rol_id != data['rol_id']:
                    modificado = True
                    self.mensajes2 += u"Cambiaste el proveedor\n"
                if documento.subtotal != data['subtotal']:
                    modificado = True
                    self.mensajes2 += u"Cambiaste el subtotal\n"
                if documento.descuento != data['descuento']:
                    modificado = True
                    self.mensajes2 += u"Cambiaste el descuento\n"
                if documento.impuesto != data['impuesto']:
                    modificado = True
                    self.mensajes2 += u"Cambiaste el impuesto\n"
                if documento.total != data['total']:
                    modificado = True
                    self.mensajes2 += u"Cambiaste el total\n"
                partidasEstaModificado = self.ui.tablaPartidas.estaModificado()
                if partidasEstaModificado:
                    modificado = True
                    self.mensajes2 += self.ui.tablaPartidas.mensajes2

                return modificado
            except:
                print sys.exc_info()
        else:
            return True


    def esValida(self):
        m = "pedidos.igu.Captura.esValida()"
        print (1), m

        valida = True
        self.mensajes = ""

        if not self.ui.fecha.lineEdit().text():
            valida = False
            self.mensajes += u"Falta la fecha\n"

        if not self.ui.cbEntidad.currentIndex() > 0:
            valida = False
            self.mensajes += u"Debe seleccionar un proveedor\n"

        partidasValidas, mensajes = self.ui.tablaPartidas.esValida()
        if not partidasValidas:
            valida = False
            self.mensajes += mensajes

        if not self.ui.edSubtotal.isValid:
            valida = False
            self.mensajes += u"Subtotal fuera de rango\n"

        if not self.ui.edDescuentoPorcentaje.isValid:
            valida = False
            self.mensajes += u"Porcentaje de descuento no válido\n"

        if not self.ui.edDescuento.isValid:
            valida = False
            self.mensajes += u"Descuento fuera de rango\n"

        if not self.ui.edImpuestoPorcentaje.isValid:
            valida = False
            self.mensajes += u"Porcentaje de impuesto no válido\n"

        if not self.ui.edImpuesto.isValid:
            valida = False
            self.mensajes += u"Impuesto fuera de rango\n"

        if not self.ui.edTotal.isValid:
            valida = False
            self.mensajes += u"Total fuera de rango\n"

        self.mensajes = self.mensajes.rstrip("\n")

        return valida


    def guarda(self):               # print "pedidos.igu.Captura.guarda()"
        ## No se revisa validez de datos, para llegar aquí se tuvo que haber hecho
        datos = self.data()

        if self.modo == "agregar":
            status = manejador.agrega(datos)
            if status == 'acepcion changed':
                self.eventRouter.emit(QtCore.SIGNAL('productosChangedBroadcast()'))
        else:
            manejador.modifica(datos)

        self.eventRouter.emit(QtCore.SIGNAL("pedidosChangedBroadcast()"))

        self.hide()

        self.emit(QtCore.SIGNAL('capturaClosed()'))


    @property
    def impuestoIncluido(self):
        return self.__impuestoIncluido


    def modifica(self, id):
        m = "pedidos.igu.Captura.modifica()"
        print (1), m

        self.__modo = 'modificar'
        self.id = id

        self.ui.titulo.setText(QtGui.QApplication.translate("Empresa Básica", "ORDEN DE COMPRA - MODIFICACIÓN", None, QtGui.QApplication.UnicodeUTF8))

        self.clear()

        proceso = manejador.procesoI(id=id)
        self.setData(proceso)

        self.ui.cbEntidad.setEnabled(False)

        self.ui.edCodigoProducto.setEnabled(True)
        self.ui.edNombreProducto.setEnabled(True)
        self.ui.cbLinea.setEnabled(True)

        self.ui.tablaPartidas.setModo(self.modo)

        self.actualizaStatus()

        self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"

        self.owner.setInnerStatus('hidden')

        self.show()


    def nombreProductoCapturado(self):
        m = "pedidos.igu.Captura.nombreProductoCapturado()"
        # print (1), m

        if self.ui.edNombreProducto.completer().completionCount() == 1:
            if self.ui.edNombreProducto.completer().popup().currentIndex().row() == -1:
                model = self.ui.edNombreProducto.completer().completionModel()
                index = model.index(0, 0)
                self.nombreProductoSeleccionado(index)


    def nombreProductoEditado(self, texto):
        m = "pedidos.igu.Captura.nombreProductoEditado()"

        # self.sender().setToolTip("Teclee las iniciales del producto que busca")
        if len(texto) < 2:
            self.ui.edNombreProducto.completer().model().clear()

        elif len(texto) == 2:
            filtros = {}

            filtros['nombre'] = unicode(texto).lower()
            filtros['rol_id'] = self.ui.cbOrigen.itemData(self.ui.cbOrigen.currentIndex()).toInt()[0]

            if self.ui.cbLinea.currentText():
                filtros['linea'] = unicode(self.ui.cbLinea.currentText())

            acepciones = manejador.dameAcepciones(**filtros)
            self.ui.edNombreProducto.completer().model().clear()

            ## Set Model Data
            for row, acepcion in enumerate(acepciones):
                self.ui.edNombreProducto.completer().model().setData(row, "%s %s %s" % (acepcion.nombre, acepcion.producto.lineas[0].nombre, acepcion.codigo))
                self.ui.edNombreProducto.completer().model().setData(row, acepcion.id, 1001)

            self.ui.edNombreProducto.completer().model().reset()


    def nombreProductoSeleccionado(self, completerModelIndex=None):  # print "pedidos.igu.Captura.nombreProductoSeleccionado()"

        completerRow = completerModelIndex.row()

        model = self.ui.edNombreProducto.completer().completionModel()

        acepcionOrigen = manejador.acepcionI(id=model.data(model.index(completerRow, 0), 1001).toInt()[0])

        ## Si no existe la acepción para el rol seleccionado, se utiliza la acepción para el origen seleccionado.
        if manejador.acepcionExists(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]):
            acepcionRol = manejador.acepcionI(producto_id=acepcionOrigen.producto.id, rol_id=self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0])
        else:
            acepcionRol = acepcionOrigen

        # ! checar el costo

        self.ui.tablaPartidas.setDatosRenglon(rowIndex=None, acepcion=acepcionRol, cantidad=dec('0.0'), precio=acepcionRol.costo)

        self.ui.edCodigoProducto.setText("")
        self.ui.edNombreProducto.setText("")
        self.ui.cbLinea.setCurrentIndex(0)

        self.ui.tablaPartidas.setCurrentCell(self.ui.tablaPartidas.rowCount()-1, CANTIDAD)
        self.ui.tablaPartidas.editItem(self.ui.tablaPartidas.item(self.ui.tablaPartidas.rowCount()-1, CANTIDAD))

        self.actualizaStatus()


    def origenChanged(self, index):

        origen = manejador.rolI(id=self.ui.cbOrigen.itemData(index).toInt()[0])

        if origen.id == self.owner.app.holder.id:
            self.ui.laNombre.setText(u" &Nombre LOCAL de artículo")
        else:
            self.ui.laNombre.setText(u" &Nombre de artículo de %s %s" % (origen.entidad.nombre, origen.entidad.nombre2))

        if len(self.ui.edNombreProducto.text()) < 2:
            self.ui.edNombreProducto.completer().model().clear()
        else:
            self.nombreProductoEditado(self.ui.edNombreProducto.text()[:2])


    @property
    def owner(self):
        return self.__owner


    def partidaCapturada(self):
        m = "pedidos.igu.Captura.partidaCapturada()"

        self.ui.tablaPartidas.clearSelection()

        self.ui.edNombreProducto.setFocus()


    def porcentajesChanged(self):   # print "pedidos.igu.Captura.porcentajesChanged()"
        self.totalChanged()


    @property
    def rangoPrecioActual(self):
        return self.__rangoPrecioActual


    def returnPressed(self):
        m = "pedidos.igu.Captura.returnPressed()"
        if self.ui.boGuardar.isEnabled():
            self.guarda()


    def setData(self, proceso):
        m = "pedidos.igu.Captura.setData()"
        print (1), m

        self.setStatus(u"settingData")

        self.old = proceso

        ## Solicitud
        operacionSolicitudCero = [x for x in proceso.operaciones if x.tipo==u'solicitud']

        documento = operacionSolicitudCero[0].documentos[0]

        self.ui.edFolio.setText("%s" % documento.folio)

        self.ui.fecha.setDate(QtCore.QDate().fromString(documento.fecha.strftime("%Y-%m-%d"), QtCore.Qt.ISODate))
        self.ui.cbEntidad.setCurrentIndex(self.ui.cbEntidad.findData(QtCore.QVariant(documento.rol_id)))

        ## Partidas
        self.ui.tablaPartidas.setDatos(documento.partidas)

        self.ui.edSubtotal.setValue(documento.subtotal)
        self.ui.edDescuento.setText("%.2f" % documento.descuento)
        if documento.descuentoporcentaje:
            self.ui.edDescuentoPorcentaje.setText("%.2f" % documento.descuentoporcentaje)
        else:
            self.ui.edDescuentoPorcentaje.setText("")
        self.ui.edImpuesto.setValue(documento.impuesto)
        if documento.impuestoporcentaje:
            self.ui.edImpuestoPorcentaje.setText("%.2f" % documento.impuestoporcentaje)
        else:
            self.ui.edImpuestoPorcentaje.setText("")
        self.ui.edTotal.setValue(documento.total)

        self.setStatus(u'normal')


    def setImpuestoIncluido(self, value):
        m = "pedidos.igu.Captura.setImpuestoIncluido()"
        # print (1), m

        if value:
            self.__impuestoIncluido = True
        else:
            self.__impuestoIncluido = False

        self.totalChanged(self.ui.tablaPartidas.subtotal())


    def setRol(self):
        m = "pedidos.igu.Captura.setRol()"
        print (1), m

        self.setCursor(QtCore.Qt.WaitCursor)

        rolId = self.ui.cbEntidad.itemData(self.ui.cbEntidad.currentIndex()).toInt()[0]

        self.ui.tablaPartidas.setRol(id=rolId)

        self.totalChanged(self.ui.tablaPartidas.subtotal())

        self.setCursor(QtCore.Qt.ArrowCursor)


    def setStatus(self, valor):
        self.__status = valor


    def showed(self):
        self.owner.owner.informacion = u"Para capturar partidas debe localizar el producto, por medio de su código o de su nombre"


    @property
    def status(self):
        return self.__status


    def totalChanged(self, subtotal=None):  # print "pedidos.igu.Captura.totalChanged()"
        if subtotal is None:
            subtotal = self.ui.edSubtotal.value()

        if self.ui.edDescuentoPorcentaje.value():
            descuento = subtotal * self.ui.edDescuentoPorcentaje.value() / dec("100")
        else:
            descuento = dec("0.00")

        total = subtotal - descuento
        if self.ui.edImpuestoPorcentaje.text():
            impuesto = total * self.ui.edImpuestoPorcentaje.value() / dec("100")
        else:
            impuesto = dec("0.00")

        total += impuesto
        self.ui.edSubtotal.setValue(subtotal)
        self.ui.edDescuento.setValue(descuento)
        self.ui.edImpuesto.setValue(impuesto)
        self.ui.edTotal.setValue(total)
        if total:
            self.ui.laCantidadConLetra.setText("Son %s" % utilities.moneyToText(dec(str(total))))
        self.actualizaStatus()



class Detalles(cdFrame.CDFrame):

    def __init__(self, *args, **kwds):

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        cdFrame.CDFrame.__init__(self, *args)

        self.ui = detalles_ui.Ui_Form()
        self.ui.setupUi(self)


        ## TABLA DE PARTIDAS
        self.ui.tablaPartidas.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
        #~ self.ui.tablaConsulta.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        #~ self.ui.tablaConsulta.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.ui.tablaPartidas.setColumnCount(6)
        self.ui.tablaPartidas.setTabKeyNavigation(False)
        self.ui.tablaPartidas.setHorizontalHeaderLabels([u"Código", u"Nombre", u"Clasificación", u"Cantidad", u"Precio", u"Importe"])
        #~ self.ui.tablaConsulta.hideColumn(0)
        #~ self.ui.tablaConsulta.horizontalHeader().setResizeMode(4, QtGui.QHeaderView.Stretch)
        #~ self.ui.tablaConsulta.setToolTip(u"ALT+D muestra detalles de la Orden seleccionada")
        #~ self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemDoubleClicked(QTableWidgetItem *)"), self.owner.toggleDetalles)
        #~ self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("itemSelectionChanged()"), self.selectionChanged)
        #~ self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("currentItemChanged(QTableWidgetItem *,QTableWidgetItem *)"), self.currentChanged)
        #~ self.connect(self.ui.tablaConsulta, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.mostrarMenuConsulta)




        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Print.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toImprimir.setIcon(icon)
        self.connect(self.ui.toImprimir, QtCore.SIGNAL("clicked()"), self.imprimirDetalles)

        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("imagenes/Redo2.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        self.ui.toExportar.setIcon(icon)
        self.ui.toExportar.setToolTip(u"Exportar a formato xls")
        self.connect(self.ui.toExportar, QtCore.SIGNAL("clicked()"), self.exportarDetalles)

        self.connect(self, QtCore.SIGNAL('doubleClicked()'), self.owner.toggleDetalles)

        self.connect(self.owner.eventRouter, QtCore.SIGNAL('pedidosChangedBroadcast()'), self.actualiza)

        self.impresor = QtGui.QPrinter()
        self.partidas = []
        self.id = None


    def actualiza(self, id=None):
        if id:
            self.setData(manejador.procesoI(id=id))
        elif self.id:
            self.setData(manejador.procesoI(id=self.id))


    def exportarDetalles(self):
        styleMainTitle = xlwt.easyxf('font:name Arial, color-index red, bold on', num_format_str='#,##0.00')
        style1 =         xlwt.easyxf(num_format_str='D-MMM-YY')
        styleField =     xlwt.easyxf('pattern:pattern solid, fore-color gray25; font:height 160; align:horiz center')
        styleHeader =    xlwt.easyxf('pattern:pattern solid, fore-color gray25; font:height 160, color-index white; align:horiz center')

        wb = xlwt.Workbook()
        ws = wb.add_sheet('Hoja 1')

        propio = manejador.damePropio()

        proceso = manejador.procesoI(id=self.id)

        ## Solicitud
        operacionSolicitudCero = [x for x in proceso.operaciones if x.tipo==u'solicitud']

        documento = operacionSolicitudCero[0].documentos[0]


        index = 0
        ws.write(index, 0, "ORDEN DE COMPRA", styleMainTitle)
        ws.write(index, 2, "Folio", styleField)
        ws.write(index, 4, "Fecha", styleField)

        index += 1
        ws.write(index, 2, documento.folio, xlwt.easyxf('font:color-index red; align: horiz center'))
        ws.write(index, 4, documento.fecha.strftime("%d %b %Y"), xlwt.easyxf('align: horiz center', num_format_str='D-MMM-YY'))

        index += 1
        ws.write(index, 0, "Emisor", styleField)
        ws.write(index, 1, "", styleField)
        ws.write(index, 2, "", styleField)
        ws.write(index, 3, "Proveedor", styleField)
        ws.write(index, 4, "", styleField)

        index += 1
        ws.write(index, 0, "%s %s" % (propio.entidad.nombre, propio.entidad.nombre2))
        ws.write(index, 2, "%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))

        index += 1
        ws.write(index, 0, "%s %s" % (propio.direcciones[0].calle, propio.direcciones[0].areanominal))
        ws.write(index, 2, "%s %s" % (documento.rol.direcciones[0].calle, documento.rol.direcciones[0].areanominal))

        index += 1
        ws.write(index, 0, "%s %s" % (propio.direcciones[0].areapostal, propio.direcciones[0].lugar.nombre))
        ws.write(index, 2, "%s %s" % (documento.rol.direcciones[0].areapostal, documento.rol.direcciones[0].lugar.nombre))

        index += 1
        ws.write(index, 0, "%s" % propio.entidad.rfc)
        ws.write(index, 2, "%s" % documento.rol.entidad.rfc)

        index += 2
        ws.write(index, 0, u"CÓDIGO", styleHeader)
        ws.write(index, 1, u"NOMBRE", styleHeader)
        ws.write(index, 2, u"CANTIDAD", styleHeader)
        ws.write(index, 3, u"COSTO", styleHeader)
        ws.write(index, 4, u"IMPORTE", styleHeader)

        index += 1
        for row, partida in enumerate(documento.partidas):
            acepcion = manejador.dameAcepcion(rol_id=documento.rol.id, producto_id=partida.producto_id)
            ws.write(index+row, 0, acepcion.codigo)
            ws.write(index+row, 1, acepcion.nombre)
            ws.write(index+row, 2, partida.cantidad, xlwt.easyxf('align: horiz center'))
            ws.write(index+row, 3, partida.costo, xlwt.easyxf(num_format_str='#,##0.00'))
            ws.write(index+row, 4, partida.cantidad * partida.costo, xlwt.easyxf(num_format_str='#,##0.00'))

        index += row + 2
        ws.write(index, 3, "Subtotal", styleField)
        ws.write(index, 4, documento.subtotal, xlwt.easyxf(num_format_str='#,##0.00'))

        index += 1
        ws.write(index, 3, "Descuentos", styleField)
        ws.write(index, 4, documento.descuento, xlwt.easyxf(num_format_str='#,##0.00'))

        index += 1
        ws.write(index, 3, "Impuestos", styleField)
        ws.write(index, 4, documento.impuesto, xlwt.easyxf(num_format_str='#,##0.00'))

        index += 1
        ws.write(index, 3, "Total", styleField)
        ws.write(index, 4, documento.total, xlwt.easyxf(num_format_str='#,##0.00'))

        ws.col(1).width = ws.col(1).width * 3

        try:
            ruta = manejador.atributoI(grupo=u'sistema', nombre=u'rutaDocumentos').valor
            filename = u"%s/OrdComp%s.xls" % (ruta, ("%s-%s%s" % (documento.folio, documento.rol.entidad.nombre, documento.rol.entidad.nombre2)).replace(" ", "").replace(".", "").replace(",", "_"))
            wb.save(filename)
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Exportación de pedido", u"Archivo %s creado" % filename, QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        except:
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Exportación de pedido", u"Ya existe", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
            print sys.exc_info()
            if sys.exc_info()[1][0]==13:
                print sys.exc_info()[1][0]



    def imprimirDetalles(self):
        margenHorizontal, margenVertical = [10, 10]
        pageNo = 1

        dialogoImpresora = QtGui.QPrintDialog(self.impresor)
        if dialogoImpresora.exec_() == QtGui.QDialog.Accepted:
            # result = QtGui.QMessageBox.information(self, u"Empresa Básica - Impresión de pedido", u"Imprimiendo ...", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)

            painter = QtGui.QPainter(self.impresor)
            painter.setFont(QtGui.QFont("courier", 10))

            pedido = self.owner.bd.get("pedidos", {'pedido_id':self.selectedId})
            proveedor = self.owner.bd.get("proveedores", {'proveedor_id':pedido['proveedor']})
            partidas = self.owner.bd.getMany("partidasPedido", {'pedido_id':pedido['pedido_id']})

            contenido = []

            margenX, margenY = [25, 75]

            x, y = [25, 0];   contenido.append([margenX + x, margenY + y, u"ORDEN DE COMPRA"])
            x, y = [200, 50]; contenido.append([margenX + x, margenY + y, u"Folio: %s" % pedido['folio']])
            x, y = [400, 50]; contenido.append([margenX + x, margenY + y, u"Fecha: %s" % pedido['fecha']])
            x, y = [0, 100];  contenido.append([margenX + x, margenY + y, u"%s %s" % (proveedor['nombre'], proveedor['apellidos'])])
            x, y = [0, 120];  contenido.append([margenX + x, margenY + y, u"%s %s" % (proveedor['calle'], proveedor['colonia'])])
            x, y = [0, 140];  contenido.append([margenX + x, margenY + y, u"%s %s" % (proveedor['codigopostal'], proveedor['lugar'])])
            x, y = [0, 160];  contenido.append([margenX + x, margenY + y, u"RFC %s" % proveedor['rfc']])
            x, y = [0, 200];  contenido.append([margenX + x, margenY + y, u"Código        Nombre                       Clasificación       Cantidad  Precio    Importe"])
            x, y = [0, 225]
            offset = 0
            for partida in partidas:
                contenido.append([margenX + x      , margenY + y + offset, "%s" % partida.producto.codigo])
                contenido.append([margenX + x + 100, margenY + y + offset, partida.producto.nombre])
                contenido.append([margenX + x + 325, margenY + y + offset, partida.producto.lineas[0].nombre])
                contenido.append([margenX + x + 525, margenY + y + offset, partida.cantidad])
                contenido.append([margenX + x + 600, margenY + y + offset, partida.costo])
                contenido.append([margenX + x + 650, margenY + y + offset, unicode(dec(partida.cantidad) * dec(partida.costo))])
                offset += 20
            x, y = [500, 240]
            contenido.append([margenX + x, margenY + y + offset, u"Subtotal"])
            x, y = [625, 240]
            contenido.append([margenX + x, margenY + y + offset, pedido['subtotal']])
            x, y = [500, 265]
            contenido.append([margenX + x, margenY + y + offset, u"Descuentos"])
            x, y = [625, 265]
            contenido.append([margenX + x, margenY + y + offset, pedido['descuento']])
            x, y = [500, 290]
            contenido.append([margenX + x, margenY + y + offset, u"IVA"])
            x, y = [625, 290]
            contenido.append([margenX + x, margenY + y + offset, pedido['impuesto']])
            x, y = [500, 315]
            contenido.append([margenX + x, margenY + y + offset, u"Total"])
            x, y = [625, 315]
            contenido.append([margenX + x, margenY + y + offset, pedido['total']])


            for item in contenido:
                painter.drawText(QtCore.QPoint(margenHorizontal + item[0], margenVertical + item[1]), item[2])


            # y = 0
            # fm = p.fontMetrics()
            # metrics = QtGui.QPaintDevice.PaintDeviceMetric(self.impresor)

            # for i in range(view.numLines()):
                # if margin + y > metrics.height() - margin:
                    # pageNo = pageNo + 1
                    # self.impresor.newPage()
                    # y = 0

                # p.drawText(margin,
                           # margin + y,
                           # metrics.width(),
                           # fm.lineSpacing(),
                           # QtCore.Qt.ExpandTabs | QtCore.Qt.DontClip,
                           # view.textLine(i))
                # y = y + fm.lineSpacing()


            # self.statusBar().message('Impresión terminada',2000)
        # else:
            # pass
            # self.statusBar().message('Impresión abortada',2000)


    # def mostrar(self, id):              # print "pedidos.igu.Detalles.mostrar()"
        # self.data = manejador.dameUno(id=id)
        # self.setData(self.data)
        # self.show()


    @property
    def owner(self):
        return self.__owner


    def setData(self, proceso):       # print "pedidos.igu.Detalles.setData()"
        self.data = proceso

        self.id = proceso.id

        ## Solicitud
        operacionSolicitudCero = [x for x in proceso.operaciones if x.tipo==u'solicitud']

        documento = operacionSolicitudCero[0].documentos[0]

        self.ui.laFolio.setText("%s" % documento.folio)
        self.ui.laFecha.setText(documento.fecha.strftime("%d %b %Y"))
        self.ui.laOrigen.setText("%s %s" % (documento.rol.entidad.nombre, documento.rol.entidad.nombre2))
        self.ui.laSubtotal.setText("%.2f" % documento.subtotal)
        self.ui.laDescuentos.setText("%.2f" % documento.descuento)
        self.ui.laImpuestos.setText("%.2f" % documento.impuesto)
        self.ui.laTotal.setText("%.2f" % documento.total)

        self.ui.tablaPartidas.setRowCount(len(documento.partidas))

        for row, partida in enumerate(documento.partidas):

            self.ui.tablaPartidas.setRowHeight(row, 20)

            acepcion = manejador.dameAcepcion(producto_id=partida.producto.id, rol_id=documento.rol_id)

            item = QtGui.QTableWidgetItem("%s" % acepcion.codigo)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaPartidas.setItem(row, 0, item)

            item = QtGui.QTableWidgetItem("%s" % acepcion.nombre)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaPartidas.setItem(row, 1, item)

            item = QtGui.QTableWidgetItem("%s" % partida.producto.lineas[0].nombre)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            self.ui.tablaPartidas.setItem(row, 2, item)

            item = QtGui.QTableWidgetItem("%s" % partida.cantidad)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignCenter)
            self.ui.tablaPartidas.setItem(row, 3, item)

            item = QtGui.QTableWidgetItem("%s" % partida.costo)
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.tablaPartidas.setItem(row, 4, item)

            item = QtGui.QTableWidgetItem("%s" % (partida.cantidad * partida.costo).quantize(dec('0.01')))
            item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
            item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter)
            self.ui.tablaPartidas.setItem(row, 5, item)

        # self.ui.tablaPartidas.horizontalHeader().setResizeMode(2, QtGui.QHeaderView.Stretch)

        self.ui.tablaPartidas.resizeColumnToContents(0)
        self.ui.tablaPartidas.resizeColumnToContents(1)
        self.ui.tablaPartidas.resizeColumnToContents(2)
        self.ui.tablaPartidas.resizeColumnToContents(3)
        self.ui.tablaPartidas.resizeColumnToContents(4)
        self.ui.tablaPartidas.resizeColumnToContents(5)


class TablaPartidas(QtGui.QTableWidget):
    """ Precios
        1000 Precio con impuesto
        1001 Precio sin impuesto
        1002 Precio de proveedor con impuesto
        1003 Precio de proveedor sin impuesto
    """

    def __init__(self, *args, **kwds):      # print "pedidos.igu.TablaPartidas.__init__()"
        if kwds.has_key('modo'):
            self.__modo = kwds.pop('modo')
        else:
            self.__modo = None

        if kwds.has_key('owner'):
            self.__owner = kwds.pop('owner')
        else:
            self.__owner = None

        QtGui.QTableWidget.__init__(self, *args)

        self.setWordWrap(False)
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        # self.setAlternatingRowColors(True)
        # self.setColumnCount(6)
        # self.setHorizontalHeaderLabels([u"Código", u"Nombre", u"Clasificación", u"Cantidad", u"Precio", u"Importe"])
        # self.horizontalHeader().setResizeMode(1, QtGui.QHeaderView.Stretch)

        self.aElimina = QtGui.QAction("Elimina", self)

        self.menu = QtGui.QMenu(self)
        self.menu.addAction(self.aElimina)

        self.connect(self, QtCore.SIGNAL("itemChanged(QTableWidgetItem *)"), self.itemChanged)
        self.connect(self, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.muestraMenu)

        self.connect(self.aElimina, QtCore.SIGNAL("triggered()"), self.elimina)

        self.status = 'normal'

        self.rol = self.owner.owner.app.holder

        delegate = Delegate(self)

        self.setItemDelegate(delegate)


    def actualizaFlags(self, *args):        # print "pedidos.igu.TablaPartidas.actualizaFlags()", args, self.rowCount()
        if args:
            if self.currentRol == self.owner.owner.app.holder.id:
                self.item(args[0], 0).setFlags(self.item(args[0], 0).flags().__xor__(QtCore.Qt.ItemIsEditable))
                self.item(args[0], 1).setFlags(self.item(args[0], 1).flags().__xor__(QtCore.Qt.ItemIsEditable))
            else:
                self.item(args[0], 0).setFlags(self.item(args[0], 0).flags().__or__(QtCore.Qt.ItemIsEditable))
                self.item(args[0], 1).setFlags(self.item(args[0], 1).flags().__or__(QtCore.Qt.ItemIsEditable))
        else:
            for row in range(self.rowCount()):
                if self.currentRol == self.owner.owner.app.holder.id:
                    self.item(row, 0).setFlags(self.item(row, 0).flags().__xor__(QtCore.Qt.ItemIsEditable))
                    self.item(row, 1).setFlags(self.item(row, 1).flags().__xor__(QtCore.Qt.ItemIsEditable))
                else:
                    self.item(row, 0).setFlags(self.item(row, 0).flags().__or__(QtCore.Qt.ItemIsEditable))
                    self.item(row, 1).setFlags(self.item(row, 1).flags().__or__(QtCore.Qt.ItemIsEditable))


    def actualizaAcepciones(self, rolId):   # print "pedidos.igu.TablaPartidas.actualizaAcepciones()"
        """ Debido a que el sistema permite el cambio de Acepciones en las tablas
            de partidas, se debe llevar un registro de las acepciones para cada
            rol que se accese """

        for row in range(self.rowCount()):
            if manejador.acepcionExiste(producto_id=self.item(row, 0).data(1000).toInt()[0], rol_id=rolId):
                acepcion = manejador.dameAcepcion(producto_id=self.item(row, 0).data(1000).toInt()[0], rol_id=rolId)
                self.setAcepcion(rolId, row, acepcion.codigo, acepcion.nombre)
            else:
                self.setAcepcion(rolId, row, self.item(row, 0).text(), self.item(row, 1).text())

            self.item(row, 0).setText('%s' % self.acepciones['%s' % rolId][row]['codigo'])
            self.item(row, 1).setText(self.acepciones['%s' % rolId][row]['nombre'])


    def data(self):
        """ El código y nombre pueden haber sido modificados por el capturista
        Puede que no se tenga id de acepción
        """
        partidas = []
        for row in range(self.rowCount()):
            partida = {}
            partida['producto_id'] = self.item(row, 0).data(1000).toInt()[0]
            partida['codigo'] = unicode(self.item(row, 0).text())
            partida['nombre'] = unicode(self.item(row, 1).text())
            try:
                partida['cantidad'] = dec(str(self.item(row, 3).text()))
            except:
                partida['cantidad'] = dec("0.00")
            try:
                partida['costo'] = dec(str(self.item(row, 4).text()))
            except:
                partida['costo'] = dec("0.00")
            try:
                partida['precio'] = dec(str(self.item(row, 4).text()))
            except:
                partida['precio'] = dec("0.00")
            partida['descuento'] = dec("0.00")
            partida['impuesto'] = manejador.impuestoGeneral()
            partida['status'] = u"pendiente"
            partidas.append(partida)
        return partidas


    def elimina(self):
        if self.currentRow() < 0:
            result = QtGui.QMessageBox.information(self, u"Empresa Básica - Eliminar partida", u"Selecciona la PARTIDA que quieres ELIMINAR", QtGui.QMessageBox.Ok, QtGui.QMessageBox.Ok)
        else:
            result = QtGui.QMessageBox.warning(self, u"Empresa Básica - Eliminar partida", u"¿Realmente quieres ELIMINAR la PARTIDA?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No)
            if result == QtGui.QMessageBox.Yes:
                self.removeRow(self.currentRow())
                self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.subtotal())


    def estaModificado(self):
        m = "pedidos.igu.TablaPartidas.estaModificado()"

        if self.modo == 'modificar':
            modificado = False
            data = self.data()
            if len(self.partidasOld) != len(data):
                modificado = True
            else:
                for index, item in enumerate(self.partidasOld):
                    if not(item.cantidad==data[index]['cantidad'] and item.costo==data[index]['costo']):
                        modificado = True
            return modificado


    def esValida(self):
        valida = True
        mensajes = ""
        if self.rowCount():
            partidas = self.data()
            for index, partida in enumerate(partidas):
                if partida['cantidad'] == dec("0.0"):
                    valida = False
                    mensajes += u"partida %s sin cantidad\n" % (index + 1)
        else:
            valida = False
            mensajes += u"No hay partidas capturadas\n"
        return valida, mensajes


    def event(self, event):
        if event.type() == QtCore.QEvent.KeyPress:
            if event.key() == QtCore.Qt.Key_Return:
                if self.currentColumn() == CANTIDAD:
                    self.setCurrentCell(self.currentRow(), PRECIO)
                elif self.currentColumn() in [PRECIO, IMPORTE]:
                    self.emit(QtCore.SIGNAL('editingFinished()'))

        return QtGui.QTableWidget.event(self, event)


    def itemChanged(self, item):            # print "pedidos.igu.TablaPartidas.itemChanged()"
        if self.status == 'normal':
            if item.column() == CANTIDAD:
                self.redraw(item)
            elif item.column() == PRECIO:
                if self.owner.impuestoIncluido:
                    item.setData(1000+self.owner.rangoPrecioActual*10, QtCore.QVariant("%s" % item.text()))
                else:
                    item.setData(1001+self.owner.rangoPrecioActual*10, QtCore.QVariant("%s" % item.text()))
                self.redraw(item)


    @property
    def modo(self):
        return self.__modo


    def muestraMenu(self, pos):
        self.setRangeSelected(QtGui.QTableWidgetSelectionRange(self.currentRow(), 0, self.currentRow(), 5), True)
        pos = self.mapToGlobal(pos)
        self.menu.popup(pos)


    @property
    def owner(self):
        return self.__owner


    def redraw(self, item=None):
        m = "pedidos.igu.TablaPartidas.redraw()"
        # print (1), m

        def redrawRow(item):
            ## Valida existencia de acepcion
            if self.item(item.row(), CODIGO).data(1001).toString() == u"No existe":
                for colIndex in [CODIGO, NOMBRE]:
                    self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFF80"))
                    self.item(item.row(), colIndex).setToolTip(u"No existe registro de producto para este Proveedor")
            else:
                for colIndex in [CODIGO, NOMBRE]:
                    self.item(item.row(), colIndex).setBackgroundColor(QtGui.QColor("#FFFFFF"))
                    self.item(item.row(), colIndex).setToolTip(u"")

            ## Validar cantidad
            if dec(str(self.item(item.row(), CANTIDAD).text())) == 0:
                # self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant("overflow"))
                self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FF8080"))
            else:
                # self.item(item.row(), CANTIDAD).setData(1001, QtCore.QVariant(""))
                self.item(item.row(), CANTIDAD).setBackgroundColor(QtGui.QColor("#FFFFFF"))

            ## Valida Precios
            if dec(str(self.item(item.row(), PRECIO).data(1000).toString())) != dec(str(self.item(item.row(), PRECIO).data(1002).toString())):
                self.item(item.row(), PRECIO).setBackgroundColor(QtGui.QColor("#FFFF80"))
                if dec(str(self.item(item.row(), PRECIO).data(1002).toString())) == dec("-1"):
                    self.item(item.row(), PRECIO).setToolTip(u"No existe registro de producto para este Proveedor")
                else:
                    self.item(item.row(), PRECIO).setToolTip(u"Este precio no es el registrado para este proveedor")
            else:
                self.item(item.row(), PRECIO).setBackgroundColor(QtGui.QColor("#FFFFFF"))
                self.item(item.row(), PRECIO).setToolTip(u"")

            ## Recalcular
            if self.owner.impuestoIncluido:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1000+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            else:
                self.item(item.row(), PRECIO).setText("%s" % dec(str(self.item(item.row(), PRECIO).data(1001+self.owner.rangoPrecioActual*10).toString())).quantize(dec('0.01')))

            importe = (dec(str(self.item(item.row(), CANTIDAD).text())) * dec(str(self.item(item.row(), PRECIO).text()))).quantize(dec('0.01'))

            self.item(item.row(), IMPORTE).setText("%s" % importe)

        if item is None:
            for rowIndex in range(self.rowCount()):
                redrawRow(self.item(rowIndex, 0))
        else:
            redrawRow(item)

        self.emit(QtCore.SIGNAL("totalChanged(dec)"), self.subtotal())


    def setAcepcion(self, rolId, row, codigo, nombre):  # print "pedidos.igu.TablaPartidas.setAcepcion()"
        try:
            if not self.acepciones.has_key('%s' % rolId):
                self.acepciones['%s' % rolId] = []
            if row >= len(self.acepciones['%s' % rolId]):
                self.acepciones['%s' % rolId].append({})
            if codigo:
                self.acepciones['%s' % rolId][row]['codigo'] = codigo
            if nombre:
                self.acepciones['%s' % rolId][row]['nombre'] = nombre
        except:
            print u"pedidos.igu.TablaPartidas.setAcepcion(rolId=%s, row=%s, codigo='%s', nombre='%s')" % (rolId, row, codigo, nombre)


    def setDatos(self, partidas):
        m = "pedidos.igu.TablaPartidas.setDatos()"

        self.partidasOld = partidas
        for index, partida in enumerate(partidas):
            acepcion = manejador.acepcionI(producto_id=partida.producto_id, rol_id=self.rol.id)

            self.setDatosRenglon(index, acepcion, partida.cantidad, partida.precio)
        # self.actualizaFlags()


    def setDatosRenglon(self, rowIndex, acepcion, cantidad, precio):
        self.status = 'insertandoRenglon'

        if rowIndex is None:
            rowIndex = self.rowCount()
            self.insertRow(self.rowCount())
        else:
            if self.rowCount() <= rowIndex:
                self.insertRow(self.rowCount())

        ## CÓDIGO
        # acepcion.codigo puede regresar Int en lugar de unicode
        item = QtGui.QTableWidgetItem("%s" % acepcion.codigo)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        item.setData(1000, QtCore.QVariant(acepcion.producto_id))
        if acepcion.rol_id==self.rol.id:
            item.setData(1001, QtCore.QVariant(u""))
        else:
            item.setData(1001, QtCore.QVariant(u"No existe"))
        self.setItem(rowIndex, CODIGO, item)

        ## NOMBRE
        item = QtGui.QTableWidgetItem(acepcion.nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, NOMBRE, item)

        ## LINEA
        item = QtGui.QTableWidgetItem(acepcion.producto.lineas[0].nombre)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, LINEA, item)

        ## IMPORTE
        item = QtGui.QTableWidgetItem("%s" % (cantidad * precio))
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignCenter)
        item.setFlags(item.flags().__xor__(QtCore.Qt.ItemIsEditable))
        self.setItem(rowIndex, IMPORTE, item)

        ## CANTIDAD
        item = QtGui.QTableWidgetItem("%s" % cantidad)
        item.setTextAlignment(QtCore.Qt.AlignCenter|QtCore.Qt.AlignCenter)
        item.setData(1000, QtCore.QVariant("%s" % acepcion.producto.maximo))
        self.setItem(rowIndex, CANTIDAD, item)

        ## PRECIO
        item = QtGui.QTableWidgetItem("%s" % precio)
        item.setTextAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignCenter)

        item.setData(1000, QtCore.QVariant("%s" % (dec(precio)*self.owner.impuestoGeneralFactor)))
        item.setData(1001, QtCore.QVariant("%s" % dec(precio)))

        item.setData(1002, QtCore.QVariant("%s" % (dec(precio)*self.owner.impuestoGeneralFactor)))
        item.setData(1003, QtCore.QVariant("%s" % dec(precio)))

        self.setItem(rowIndex, PRECIO, item)

        self.redraw(self.item(rowIndex, 0))

        self.status = 'normal'

        self.resizeColumnToContents(CODIGO)
        self.resizeColumnToContents(LINEA)
        self.resizeColumnToContents(CANTIDAD)
        self.resizeColumnToContents(PRECIO)
        self.resizeColumnToContents(IMPORTE)

        self.owner.owner.owner.informacion = u"Presiona F2 para modificar datos en la celda"



    def setModo(self, modo):                # print "pedidos.igu.TablaPartidas.setModo()"
        self.__modo = modo

        if modo == 'agregar':
            self.menu = QtGui.QMenu(self)
            self.menu.addAction(self.aElimina)
        elif modo == 'modificar':
            self.menu = QtGui.QMenu(self)


    def setRol(self, rol=None, id=None):
        """ Recibe instancia de Rol o id de Rol
            Actualiza codigo y nombre de cada renglón de la tabla de partidas
            Según si existe con la acepción del rol recibido, con la acepción del rol de origen seleccionado o con la acepción local.
            En caso de registrarse los datos y no existir la acepción del rol recibido, se crea con los datos de la acepción capturada.
        """
        m = "pedidos.igu.TablaPartidas.setRol()"
        # print (1), m

        if rol:
            self.rol = rol
        elif id:
            self.rol = manejador.rolI(id=id)

        if self.rol.id == self.owner.owner.app.holder.id:
            self.horizontalHeaderItem(1).setText(u"Nombre LOCAL de artículo")
        else:
            self.horizontalHeaderItem(1).setText(u"Nombre de artículo para %s %s" % (self.rol.entidad.nombre, self.rol.entidad.nombre2))

        for rowIndex in range(self.rowCount()):

            if manejador.acepcionExists(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.rol.id):
                acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.rol.id)
                self.item(rowIndex, CODIGO).setData(1001, QtCore.QVariant(u""))

                self.item(rowIndex, PRECIO).setData(1002, QtCore.QVariant("%s" % (acepcion.costo*self.owner.impuestoGeneralFactor)))
                self.item(rowIndex, PRECIO).setData(1003, QtCore.QVariant("%s" % acepcion.costo))

            else:
                if manejador.acepcionExists(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.ui.cbOrigen.itemData(self.owner.ui.cbOrigen.currentIndex()).toInt()[0]):
                    ## Si no existe la acepción para el rol seleccionado, se busca la acepción para el rol de origen seleccionado
                    acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.ui.cbOrigen.itemData(self.owner.ui.cbOrigen.currentIndex()).toInt()[0])
                else:
                    ## Si no existe la acepción para el rol de origen, se busca la acepción local
                    acepcion = manejador.acepcionI(producto_id=self.item(rowIndex, CODIGO).data(1000).toInt()[0], rol_id=self.owner.owner.app.holder.id)

                self.item(rowIndex, CODIGO).setData(1001, QtCore.QVariant(u"No existe"))

                self.item(rowIndex, PRECIO).setData(1002, QtCore.QVariant("-1"))
                self.item(rowIndex, PRECIO).setData(1003, QtCore.QVariant("-1"))

            self.item(rowIndex, CODIGO).setText("%s" % acepcion.codigo)
            self.item(rowIndex, NOMBRE).setText("%s" % acepcion.nombre)

        self.redraw()


    def subtotal(self):                     # print "pedidos.igu.TablaPartidas.subtotal()"
        subtotal = dec("0.00")
        for row in range(self.rowCount()):
            importe = dec(str(self.item(row, IMPORTE).text()))
            subtotal += importe
        return subtotal


class Delegate(QtGui.QItemDelegate):

    def createEditor(self, parent, option, index):
        if index.column() == CANTIDAD:
            editor = cdNumberEdit.CDNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        if index.column() == PRECIO:
            editor = cdNumberEdit.CDNumberEdit(parent)
            editor.hasStatusLabel(False)
            self.connect(editor, QtCore.SIGNAL('returnPressed()'), self.commitAndCloseEditor)
            return editor
        else:
            return QtGui.QItemDelegate.createEditor(self, parent, option, index)

    def commitAndCloseEditor(self):
        editor = self.sender()
        if isinstance(editor, (QtGui.QTextEdit, QtGui.QLineEdit)):
            self.emit(QtCore.SIGNAL('commitData(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('closeEditor(QWidget*)'), editor)
            self.emit(QtCore.SIGNAL('editingFinished(QWidget*)'), editor)



class Splitter(QtGui.QSplitter):

    def __init__(self, *args):
        self.orientation = args[0]
        QtGui.QSplitter.__init__(self, *args)

    def createHandle(self):
        return Handle(self.orientation, self)



class Handle(QtGui.QSplitterHandle):

    def __init__(self, *args):
        QtGui.QSplitterHandle.__init__(self, *args)

    def mouseDoubleClickEvent(self, event):       # print "Handle.mousePressEvent()"
        self.emit(QtCore.SIGNAL("handlePressed"))


class Model(QtCore.QAbstractListModel):

    def __init__(self, *args):
        QtCore.QAbstractListModel.__init__(self, *args)
        self.__data = []


    def clear(self):
        # self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.__data = []
        self.reset()
        # self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            return self.__data[index.row()][index.column()]
        elif role == QtCore.Qt.TextAlignmentRole:
            # if index.column() == CANTIDAD:
                # return QtCore.QVariant(int(QtCore.Qt.AlignCenter|QtCore.Qt.AlignVCenter))
            # if index.column() in [PRECIO, IMPORTE]:
                # return QtCore.QVariant(int(QtCore.Qt.AlignRight|QtCore.Qt.AlignVCenter))
            return QtCore.QVariant(int(QtCore.Qt.AlignLeft|QtCore.Qt.AlignVCenter))
        elif role == 1001:
            return self.__data[index.row()][1]
        else:
            return QtCore.QVariant()


    def insertRow(self, row, parent=QtCore.QModelIndex()):
        self.__data.insert(row, [QtCore.QVariant(u""), QtCore.QVariant(u"")])
        return True


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.__data)


    def setData(self, row, valor, role=QtCore.Qt.DisplayRole):
        """ No se usa la porquería de modelIndex """
        if row >= len(self.__data):
            self.__data.append([None, None])

        if role in [QtCore.Qt.DisplayRole, QtCore.Qt.EditRole]:
            self.__data[row][0] = QtCore.QVariant(valor)
        elif role == 1001:
            self.__data[row][1] = QtCore.QVariant(valor)
        else:
            print "puaj"
        return True



"""
Estados de Pedidos
    pendiente
    autorizada
    remitida
    aceptada
    surtida

Si el estado de un pedido no es "pendiente", será imposible modificarla o
    eliminarla

"""

# background-color:qlineargradient(x1: 0, y1: 0, x2:1, y2:.1, stop: 0 #E0E0E0, stop:0.4#F8F8F8, stop:1 #B0B0B0); border-top-left-radius: 3px; border-top-right-radius: 3px;

if __name__ == "__main__":
    print 'yep'


# print (0), "  pedidos.igu       end"
